// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.nav.sell.order.detail;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.NavSellOrderDetail;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(NavSellOrderDetail.class)
@Setter
@Getter
public class NavSellOrderDetailSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "NavSellOrderDetail".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentNavSellOrder", "nso");
    map.put("productId", "p");
    map.put("type", "c");
    map.put("shopInfo", "si");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属订单管理
   */
  private Long parentNavSellOrder;

  /**
   * 所属订单管理 比较(eq)
   */
  private Long parentNavSellOrderEq;
  /**
   * 所属订单管理 比较(neq)
   */
  private Long parentNavSellOrderNeq;
  /**
   * 所属订单管理 比较(gt)
   */
  private Long parentNavSellOrderGt;
  /**
   * 所属订单管理 比较(gte)
   */
  private Long parentNavSellOrderGte;
  /**
   * 所属订单管理 比较(lt)
   */
  private Long parentNavSellOrderLt;
  /**
   * 所属订单管理 比较(lte)
   */
  private Long parentNavSellOrderLte;
  /**
   * 所属订单管理 比较(contains)
   */
  private Long parentNavSellOrderContains;
  /**
   * 所属订单管理 比较(notcontains)
   */
  private Long parentNavSellOrderNotcontains;
  /**
   * 所属订单管理 比较(startswith)
   */
  private Long parentNavSellOrderStartswith;
  /**
   * 所属订单管理 比较(endswith)
   */
  private Long parentNavSellOrderEndswith;
  /**
   * 所属订单管理 比较(isnull)
   */
  private Boolean parentNavSellOrderIsnull;
  /**
   * 所属订单管理 比较(isnotnull)
   */
  private Boolean parentNavSellOrderIsnotnull;
  /**
   * 所属订单管理的系统单号 比较(eq)
   */
  private String parentNavSellOrderOrderIdEq;
  /**
   * 所属订单管理的系统单号 比较(neq)
   */
  private String parentNavSellOrderOrderIdNeq;
  /**
   * 所属订单管理的系统单号 比较(gt)
   */
  private String parentNavSellOrderOrderIdGt;
  /**
   * 所属订单管理的系统单号 比较(gte)
   */
  private String parentNavSellOrderOrderIdGte;
  /**
   * 所属订单管理的系统单号 比较(lt)
   */
  private String parentNavSellOrderOrderIdLt;
  /**
   * 所属订单管理的系统单号 比较(lte)
   */
  private String parentNavSellOrderOrderIdLte;
  /**
   * 所属订单管理的系统单号 比较(contains)
   */
  private String parentNavSellOrderOrderIdContains;
  /**
   * 所属订单管理的系统单号 比较(notcontains)
   */
  private String parentNavSellOrderOrderIdNotcontains;
  /**
   * 所属订单管理的系统单号 比较(startswith)
   */
  private String parentNavSellOrderOrderIdStartswith;
  /**
   * 所属订单管理的系统单号 比较(endswith)
   */
  private String parentNavSellOrderOrderIdEndswith;
  /**
   * 所属订单管理的系统单号 比较(isnull)
   */
  private Boolean parentNavSellOrderOrderIdIsnull;
  /**
   * 所属订单管理的系统单号 比较(isnotnull)
   */
  private Boolean parentNavSellOrderOrderIdIsnotnull;

  /**
   * 所属订单管理(范围搜索)
   */
  private List<Long> parentNavSellOrderInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 平台单号(模糊搜索)
   */
  private String platformOrderId;

  /**
   * 平台单号 比较(eq)
   */
  private String platformOrderIdEq;
  /**
   * 平台单号 比较(neq)
   */
  private String platformOrderIdNeq;
  /**
   * 平台单号 比较(gt)
   */
  private String platformOrderIdGt;
  /**
   * 平台单号 比较(gte)
   */
  private String platformOrderIdGte;
  /**
   * 平台单号 比较(lt)
   */
  private String platformOrderIdLt;
  /**
   * 平台单号 比较(lte)
   */
  private String platformOrderIdLte;
  /**
   * 平台单号 比较(contains)
   */
  private String platformOrderIdContains;
  /**
   * 平台单号 比较(notcontains)
   */
  private String platformOrderIdNotcontains;
  /**
   * 平台单号 比较(startswith)
   */
  private String platformOrderIdStartswith;
  /**
   * 平台单号 比较(endswith)
   */
  private String platformOrderIdEndswith;
  /**
   * 平台单号 比较(isnull)
   */
  private Boolean platformOrderIdIsnull;
  /**
   * 平台单号 比较(isnotnull)
   */
  private Boolean platformOrderIdIsnotnull;

  /**
   * 平台单号(精确搜索)
   */
  private List<String> platformOrderIdInList;

  /**
   * 参考号(模糊搜索)
   */
  private String referenceId;

  /**
   * 参考号 比较(eq)
   */
  private String referenceIdEq;
  /**
   * 参考号 比较(neq)
   */
  private String referenceIdNeq;
  /**
   * 参考号 比较(gt)
   */
  private String referenceIdGt;
  /**
   * 参考号 比较(gte)
   */
  private String referenceIdGte;
  /**
   * 参考号 比较(lt)
   */
  private String referenceIdLt;
  /**
   * 参考号 比较(lte)
   */
  private String referenceIdLte;
  /**
   * 参考号 比较(contains)
   */
  private String referenceIdContains;
  /**
   * 参考号 比较(notcontains)
   */
  private String referenceIdNotcontains;
  /**
   * 参考号 比较(startswith)
   */
  private String referenceIdStartswith;
  /**
   * 参考号 比较(endswith)
   */
  private String referenceIdEndswith;
  /**
   * 参考号 比较(isnull)
   */
  private Boolean referenceIdIsnull;
  /**
   * 参考号 比较(isnotnull)
   */
  private Boolean referenceIdIsnotnull;

  /**
   * 参考号(精确搜索)
   */
  private List<String> referenceIdInList;

  /**
   * 商品来源
   */
  private String itemFromName;

  /**
   * 商品来源 比较(eq)
   */
  private String itemFromNameEq;
  /**
   * 商品来源 比较(neq)
   */
  private String itemFromNameNeq;
  /**
   * 商品来源 比较(gt)
   */
  private String itemFromNameGt;
  /**
   * 商品来源 比较(gte)
   */
  private String itemFromNameGte;
  /**
   * 商品来源 比较(lt)
   */
  private String itemFromNameLt;
  /**
   * 商品来源 比较(lte)
   */
  private String itemFromNameLte;
  /**
   * 商品来源 比较(contains)
   */
  private String itemFromNameContains;
  /**
   * 商品来源 比较(notcontains)
   */
  private String itemFromNameNotcontains;
  /**
   * 商品来源 比较(startswith)
   */
  private String itemFromNameStartswith;
  /**
   * 商品来源 比较(endswith)
   */
  private String itemFromNameEndswith;
  /**
   * 商品来源 比较(isnull)
   */
  private Boolean itemFromNameIsnull;
  /**
   * 商品来源 比较(isnotnull)
   */
  private Boolean itemFromNameIsnotnull;

  /**
   * 商品来源(精确搜索)
   */
  private List<String> itemFromNameInList;

  /**
   * 是否有 图片
   */
  private Boolean img;

  /**
   * 产品
   */
  private Long productId;

  /**
   * 产品 比较(eq)
   */
  private Long productIdEq;
  /**
   * 产品 比较(neq)
   */
  private Long productIdNeq;
  /**
   * 产品 比较(gt)
   */
  private Long productIdGt;
  /**
   * 产品 比较(gte)
   */
  private Long productIdGte;
  /**
   * 产品 比较(lt)
   */
  private Long productIdLt;
  /**
   * 产品 比较(lte)
   */
  private Long productIdLte;
  /**
   * 产品 比较(contains)
   */
  private Long productIdContains;
  /**
   * 产品 比较(notcontains)
   */
  private Long productIdNotcontains;
  /**
   * 产品 比较(startswith)
   */
  private Long productIdStartswith;
  /**
   * 产品 比较(endswith)
   */
  private Long productIdEndswith;
  /**
   * 产品 比较(isnull)
   */
  private Boolean productIdIsnull;
  /**
   * 产品 比较(isnotnull)
   */
  private Boolean productIdIsnotnull;
  /**
   * 产品的品名 比较(eq)
   */
  private String productIdNameEq;
  /**
   * 产品的品名 比较(neq)
   */
  private String productIdNameNeq;
  /**
   * 产品的品名 比较(gt)
   */
  private String productIdNameGt;
  /**
   * 产品的品名 比较(gte)
   */
  private String productIdNameGte;
  /**
   * 产品的品名 比较(lt)
   */
  private String productIdNameLt;
  /**
   * 产品的品名 比较(lte)
   */
  private String productIdNameLte;
  /**
   * 产品的品名 比较(contains)
   */
  private String productIdNameContains;
  /**
   * 产品的品名 比较(notcontains)
   */
  private String productIdNameNotcontains;
  /**
   * 产品的品名 比较(startswith)
   */
  private String productIdNameStartswith;
  /**
   * 产品的品名 比较(endswith)
   */
  private String productIdNameEndswith;
  /**
   * 产品的品名 比较(isnull)
   */
  private Boolean productIdNameIsnull;
  /**
   * 产品的品名 比较(isnotnull)
   */
  private Boolean productIdNameIsnotnull;

  /**
   * 产品(范围搜索)
   */
  private List<Long> productIdInList;

  /**
   * 品名(模糊搜索)
   */
  private String productName;

  /**
   * 品名 比较(eq)
   */
  private String productNameEq;
  /**
   * 品名 比较(neq)
   */
  private String productNameNeq;
  /**
   * 品名 比较(gt)
   */
  private String productNameGt;
  /**
   * 品名 比较(gte)
   */
  private String productNameGte;
  /**
   * 品名 比较(lt)
   */
  private String productNameLt;
  /**
   * 品名 比较(lte)
   */
  private String productNameLte;
  /**
   * 品名 比较(contains)
   */
  private String productNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private String productNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private String productNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private String productNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;

  /**
   * 品名(精确搜索)
   */
  private List<String> productNameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * 销售收益
   */
  private java.math.BigDecimal salesRevenueAmount;

  /**
   * 最小销售收益
   */
  private java.math.BigDecimal salesRevenueAmountMin;

  /**
   * 最大销售收益
   */
  private java.math.BigDecimal salesRevenueAmountMax;

  /**
   * 销售收益 比较(eq)
   */
  private java.math.BigDecimal salesRevenueAmountEq;
  /**
   * 销售收益 比较(neq)
   */
  private java.math.BigDecimal salesRevenueAmountNeq;
  /**
   * 销售收益 比较(gt)
   */
  private java.math.BigDecimal salesRevenueAmountGt;
  /**
   * 销售收益 比较(gte)
   */
  private java.math.BigDecimal salesRevenueAmountGte;
  /**
   * 销售收益 比较(lt)
   */
  private java.math.BigDecimal salesRevenueAmountLt;
  /**
   * 销售收益 比较(lte)
   */
  private java.math.BigDecimal salesRevenueAmountLte;
  /**
   * 销售收益 比较(contains)
   */
  private java.math.BigDecimal salesRevenueAmountContains;
  /**
   * 销售收益 比较(notcontains)
   */
  private java.math.BigDecimal salesRevenueAmountNotcontains;
  /**
   * 销售收益 比较(startswith)
   */
  private java.math.BigDecimal salesRevenueAmountStartswith;
  /**
   * 销售收益 比较(endswith)
   */
  private java.math.BigDecimal salesRevenueAmountEndswith;
  /**
   * 销售收益 比较(isnull)
   */
  private Boolean salesRevenueAmountIsnull;
  /**
   * 销售收益 比较(isnotnull)
   */
  private Boolean salesRevenueAmountIsnotnull;

  /**
   * 商品类型
   */
  private Long type;

  /**
   * 商品类型 比较(eq)
   */
  private Long typeEq;
  /**
   * 商品类型 比较(neq)
   */
  private Long typeNeq;
  /**
   * 商品类型 比较(gt)
   */
  private Long typeGt;
  /**
   * 商品类型 比较(gte)
   */
  private Long typeGte;
  /**
   * 商品类型 比较(lt)
   */
  private Long typeLt;
  /**
   * 商品类型 比较(lte)
   */
  private Long typeLte;
  /**
   * 商品类型 比较(contains)
   */
  private Long typeContains;
  /**
   * 商品类型 比较(notcontains)
   */
  private Long typeNotcontains;
  /**
   * 商品类型 比较(startswith)
   */
  private Long typeStartswith;
  /**
   * 商品类型 比较(endswith)
   */
  private Long typeEndswith;
  /**
   * 商品类型 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 商品类型 比较(isnotnull)
   */
  private Boolean typeIsnotnull;
  /**
   * 商品类型的分类名称 比较(eq)
   */
  private String typeNameEq;
  /**
   * 商品类型的分类名称 比较(neq)
   */
  private String typeNameNeq;
  /**
   * 商品类型的分类名称 比较(gt)
   */
  private String typeNameGt;
  /**
   * 商品类型的分类名称 比较(gte)
   */
  private String typeNameGte;
  /**
   * 商品类型的分类名称 比较(lt)
   */
  private String typeNameLt;
  /**
   * 商品类型的分类名称 比较(lte)
   */
  private String typeNameLte;
  /**
   * 商品类型的分类名称 比较(contains)
   */
  private String typeNameContains;
  /**
   * 商品类型的分类名称 比较(notcontains)
   */
  private String typeNameNotcontains;
  /**
   * 商品类型的分类名称 比较(startswith)
   */
  private String typeNameStartswith;
  /**
   * 商品类型的分类名称 比较(endswith)
   */
  private String typeNameEndswith;
  /**
   * 商品类型的分类名称 比较(isnull)
   */
  private Boolean typeNameIsnull;
  /**
   * 商品类型的分类名称 比较(isnotnull)
   */
  private Boolean typeNameIsnotnull;

  /**
   * 商品类型(范围搜索)
   */
  private List<Long> typeInList;

  /**
   * 单价
   */
  private java.math.BigDecimal price;

  /**
   * 最小单价
   */
  private java.math.BigDecimal priceMin;

  /**
   * 最大单价
   */
  private java.math.BigDecimal priceMax;

  /**
   * 单价 比较(eq)
   */
  private java.math.BigDecimal priceEq;
  /**
   * 单价 比较(neq)
   */
  private java.math.BigDecimal priceNeq;
  /**
   * 单价 比较(gt)
   */
  private java.math.BigDecimal priceGt;
  /**
   * 单价 比较(gte)
   */
  private java.math.BigDecimal priceGte;
  /**
   * 单价 比较(lt)
   */
  private java.math.BigDecimal priceLt;
  /**
   * 单价 比较(lte)
   */
  private java.math.BigDecimal priceLte;
  /**
   * 单价 比较(contains)
   */
  private java.math.BigDecimal priceContains;
  /**
   * 单价 比较(notcontains)
   */
  private java.math.BigDecimal priceNotcontains;
  /**
   * 单价 比较(startswith)
   */
  private java.math.BigDecimal priceStartswith;
  /**
   * 单价 比较(endswith)
   */
  private java.math.BigDecimal priceEndswith;
  /**
   * 单价 比较(isnull)
   */
  private Boolean priceIsnull;
  /**
   * 单价 比较(isnotnull)
   */
  private Boolean priceIsnotnull;

  /**
   * 数量
   */
  private Integer quantity;

  /**
   * 最小数量
   */
  private Integer quantityMin;

  /**
   * 最大数量
   */
  private Integer quantityMax;

  /**
   * 数量 比较(eq)
   */
  private Integer quantityEq;
  /**
   * 数量 比较(neq)
   */
  private Integer quantityNeq;
  /**
   * 数量 比较(gt)
   */
  private Integer quantityGt;
  /**
   * 数量 比较(gte)
   */
  private Integer quantityGte;
  /**
   * 数量 比较(lt)
   */
  private Integer quantityLt;
  /**
   * 数量 比较(lte)
   */
  private Integer quantityLte;
  /**
   * 数量 比较(contains)
   */
  private Integer quantityContains;
  /**
   * 数量 比较(notcontains)
   */
  private Integer quantityNotcontains;
  /**
   * 数量 比较(startswith)
   */
  private Integer quantityStartswith;
  /**
   * 数量 比较(endswith)
   */
  private Integer quantityEndswith;
  /**
   * 数量 比较(isnull)
   */
  private Boolean quantityIsnull;
  /**
   * 数量 比较(isnotnull)
   */
  private Boolean quantityIsnotnull;

  /**
   * 可用量
   */
  private Integer availableQuantity;

  /**
   * 最小可用量
   */
  private Integer availableQuantityMin;

  /**
   * 最大可用量
   */
  private Integer availableQuantityMax;

  /**
   * 可用量 比较(eq)
   */
  private Integer availableQuantityEq;
  /**
   * 可用量 比较(neq)
   */
  private Integer availableQuantityNeq;
  /**
   * 可用量 比较(gt)
   */
  private Integer availableQuantityGt;
  /**
   * 可用量 比较(gte)
   */
  private Integer availableQuantityGte;
  /**
   * 可用量 比较(lt)
   */
  private Integer availableQuantityLt;
  /**
   * 可用量 比较(lte)
   */
  private Integer availableQuantityLte;
  /**
   * 可用量 比较(contains)
   */
  private Integer availableQuantityContains;
  /**
   * 可用量 比较(notcontains)
   */
  private Integer availableQuantityNotcontains;
  /**
   * 可用量 比较(startswith)
   */
  private Integer availableQuantityStartswith;
  /**
   * 可用量 比较(endswith)
   */
  private Integer availableQuantityEndswith;
  /**
   * 可用量 比较(isnull)
   */
  private Boolean availableQuantityIsnull;
  /**
   * 可用量 比较(isnotnull)
   */
  private Boolean availableQuantityIsnotnull;

  /**
   * 变体属性(模糊搜索)
   */
  private String attribute;

  /**
   * 变体属性 比较(eq)
   */
  private String attributeEq;
  /**
   * 变体属性 比较(neq)
   */
  private String attributeNeq;
  /**
   * 变体属性 比较(gt)
   */
  private String attributeGt;
  /**
   * 变体属性 比较(gte)
   */
  private String attributeGte;
  /**
   * 变体属性 比较(lt)
   */
  private String attributeLt;
  /**
   * 变体属性 比较(lte)
   */
  private String attributeLte;
  /**
   * 变体属性 比较(contains)
   */
  private String attributeContains;
  /**
   * 变体属性 比较(notcontains)
   */
  private String attributeNotcontains;
  /**
   * 变体属性 比较(startswith)
   */
  private String attributeStartswith;
  /**
   * 变体属性 比较(endswith)
   */
  private String attributeEndswith;
  /**
   * 变体属性 比较(isnull)
   */
  private Boolean attributeIsnull;
  /**
   * 变体属性 比较(isnotnull)
   */
  private Boolean attributeIsnotnull;

  /**
   * 变体属性(精确搜索)
   */
  private List<String> attributeInList;

  /**
   * 中文申报名(模糊搜索)
   */
  private String chineseName;

  /**
   * 中文申报名 比较(eq)
   */
  private String chineseNameEq;
  /**
   * 中文申报名 比较(neq)
   */
  private String chineseNameNeq;
  /**
   * 中文申报名 比较(gt)
   */
  private String chineseNameGt;
  /**
   * 中文申报名 比较(gte)
   */
  private String chineseNameGte;
  /**
   * 中文申报名 比较(lt)
   */
  private String chineseNameLt;
  /**
   * 中文申报名 比较(lte)
   */
  private String chineseNameLte;
  /**
   * 中文申报名 比较(contains)
   */
  private String chineseNameContains;
  /**
   * 中文申报名 比较(notcontains)
   */
  private String chineseNameNotcontains;
  /**
   * 中文申报名 比较(startswith)
   */
  private String chineseNameStartswith;
  /**
   * 中文申报名 比较(endswith)
   */
  private String chineseNameEndswith;
  /**
   * 中文申报名 比较(isnull)
   */
  private Boolean chineseNameIsnull;
  /**
   * 中文申报名 比较(isnotnull)
   */
  private Boolean chineseNameIsnotnull;

  /**
   * 中文申报名(精确搜索)
   */
  private List<String> chineseNameInList;

  /**
   * 英文申报名(模糊搜索)
   */
  private String englishName;

  /**
   * 英文申报名 比较(eq)
   */
  private String englishNameEq;
  /**
   * 英文申报名 比较(neq)
   */
  private String englishNameNeq;
  /**
   * 英文申报名 比较(gt)
   */
  private String englishNameGt;
  /**
   * 英文申报名 比较(gte)
   */
  private String englishNameGte;
  /**
   * 英文申报名 比较(lt)
   */
  private String englishNameLt;
  /**
   * 英文申报名 比较(lte)
   */
  private String englishNameLte;
  /**
   * 英文申报名 比较(contains)
   */
  private String englishNameContains;
  /**
   * 英文申报名 比较(notcontains)
   */
  private String englishNameNotcontains;
  /**
   * 英文申报名 比较(startswith)
   */
  private String englishNameStartswith;
  /**
   * 英文申报名 比较(endswith)
   */
  private String englishNameEndswith;
  /**
   * 英文申报名 比较(isnull)
   */
  private Boolean englishNameIsnull;
  /**
   * 英文申报名 比较(isnotnull)
   */
  private Boolean englishNameIsnotnull;

  /**
   * 英文申报名(精确搜索)
   */
  private List<String> englishNameInList;

  /**
   * 备货店铺
   */
  private Long shopInfo;

  /**
   * 备货店铺 比较(eq)
   */
  private Long shopInfoEq;
  /**
   * 备货店铺 比较(neq)
   */
  private Long shopInfoNeq;
  /**
   * 备货店铺 比较(gt)
   */
  private Long shopInfoGt;
  /**
   * 备货店铺 比较(gte)
   */
  private Long shopInfoGte;
  /**
   * 备货店铺 比较(lt)
   */
  private Long shopInfoLt;
  /**
   * 备货店铺 比较(lte)
   */
  private Long shopInfoLte;
  /**
   * 备货店铺 比较(contains)
   */
  private Long shopInfoContains;
  /**
   * 备货店铺 比较(notcontains)
   */
  private Long shopInfoNotcontains;
  /**
   * 备货店铺 比较(startswith)
   */
  private Long shopInfoStartswith;
  /**
   * 备货店铺 比较(endswith)
   */
  private Long shopInfoEndswith;
  /**
   * 备货店铺 比较(isnull)
   */
  private Boolean shopInfoIsnull;
  /**
   * 备货店铺 比较(isnotnull)
   */
  private Boolean shopInfoIsnotnull;
  /**
   * 备货店铺的名称 比较(eq)
   */
  private String shopInfoShopNameEq;
  /**
   * 备货店铺的名称 比较(neq)
   */
  private String shopInfoShopNameNeq;
  /**
   * 备货店铺的名称 比较(gt)
   */
  private String shopInfoShopNameGt;
  /**
   * 备货店铺的名称 比较(gte)
   */
  private String shopInfoShopNameGte;
  /**
   * 备货店铺的名称 比较(lt)
   */
  private String shopInfoShopNameLt;
  /**
   * 备货店铺的名称 比较(lte)
   */
  private String shopInfoShopNameLte;
  /**
   * 备货店铺的名称 比较(contains)
   */
  private String shopInfoShopNameContains;
  /**
   * 备货店铺的名称 比较(notcontains)
   */
  private String shopInfoShopNameNotcontains;
  /**
   * 备货店铺的名称 比较(startswith)
   */
  private String shopInfoShopNameStartswith;
  /**
   * 备货店铺的名称 比较(endswith)
   */
  private String shopInfoShopNameEndswith;
  /**
   * 备货店铺的名称 比较(isnull)
   */
  private Boolean shopInfoShopNameIsnull;
  /**
   * 备货店铺的名称 比较(isnotnull)
   */
  private Boolean shopInfoShopNameIsnotnull;

  /**
   * 备货店铺(范围搜索)
   */
  private List<Long> shopInfoInList;

  /**
   * 捆绑类型(模糊搜索)
   */
  private String bundleType;

  /**
   * 捆绑类型 比较(eq)
   */
  private String bundleTypeEq;
  /**
   * 捆绑类型 比较(neq)
   */
  private String bundleTypeNeq;
  /**
   * 捆绑类型 比较(gt)
   */
  private String bundleTypeGt;
  /**
   * 捆绑类型 比较(gte)
   */
  private String bundleTypeGte;
  /**
   * 捆绑类型 比较(lt)
   */
  private String bundleTypeLt;
  /**
   * 捆绑类型 比较(lte)
   */
  private String bundleTypeLte;
  /**
   * 捆绑类型 比较(contains)
   */
  private String bundleTypeContains;
  /**
   * 捆绑类型 比较(notcontains)
   */
  private String bundleTypeNotcontains;
  /**
   * 捆绑类型 比较(startswith)
   */
  private String bundleTypeStartswith;
  /**
   * 捆绑类型 比较(endswith)
   */
  private String bundleTypeEndswith;
  /**
   * 捆绑类型 比较(isnull)
   */
  private Boolean bundleTypeIsnull;
  /**
   * 捆绑类型 比较(isnotnull)
   */
  private Boolean bundleTypeIsnotnull;

  /**
   * 捆绑类型(精确搜索)
   */
  private List<String> bundleTypeInList;

  /**
   * 捆绑产品wod_id(模糊搜索)
   */
  private String bundleWodId;

  /**
   * 捆绑产品wod_id 比较(eq)
   */
  private String bundleWodIdEq;
  /**
   * 捆绑产品wod_id 比较(neq)
   */
  private String bundleWodIdNeq;
  /**
   * 捆绑产品wod_id 比较(gt)
   */
  private String bundleWodIdGt;
  /**
   * 捆绑产品wod_id 比较(gte)
   */
  private String bundleWodIdGte;
  /**
   * 捆绑产品wod_id 比较(lt)
   */
  private String bundleWodIdLt;
  /**
   * 捆绑产品wod_id 比较(lte)
   */
  private String bundleWodIdLte;
  /**
   * 捆绑产品wod_id 比较(contains)
   */
  private String bundleWodIdContains;
  /**
   * 捆绑产品wod_id 比较(notcontains)
   */
  private String bundleWodIdNotcontains;
  /**
   * 捆绑产品wod_id 比较(startswith)
   */
  private String bundleWodIdStartswith;
  /**
   * 捆绑产品wod_id 比较(endswith)
   */
  private String bundleWodIdEndswith;
  /**
   * 捆绑产品wod_id 比较(isnull)
   */
  private Boolean bundleWodIdIsnull;
  /**
   * 捆绑产品wod_id 比较(isnotnull)
   */
  private Boolean bundleWodIdIsnotnull;

  /**
   * 捆绑产品wod_id(精确搜索)
   */
  private List<String> bundleWodIdInList;

  /**
   * 客付税费
   */
  private java.math.BigDecimal tax;

  /**
   * 最小客付税费
   */
  private java.math.BigDecimal taxMin;

  /**
   * 最大客付税费
   */
  private java.math.BigDecimal taxMax;

  /**
   * 客付税费 比较(eq)
   */
  private java.math.BigDecimal taxEq;
  /**
   * 客付税费 比较(neq)
   */
  private java.math.BigDecimal taxNeq;
  /**
   * 客付税费 比较(gt)
   */
  private java.math.BigDecimal taxGt;
  /**
   * 客付税费 比较(gte)
   */
  private java.math.BigDecimal taxGte;
  /**
   * 客付税费 比较(lt)
   */
  private java.math.BigDecimal taxLt;
  /**
   * 客付税费 比较(lte)
   */
  private java.math.BigDecimal taxLte;
  /**
   * 客付税费 比较(contains)
   */
  private java.math.BigDecimal taxContains;
  /**
   * 客付税费 比较(notcontains)
   */
  private java.math.BigDecimal taxNotcontains;
  /**
   * 客付税费 比较(startswith)
   */
  private java.math.BigDecimal taxStartswith;
  /**
   * 客付税费 比较(endswith)
   */
  private java.math.BigDecimal taxEndswith;
  /**
   * 客付税费 比较(isnull)
   */
  private Boolean taxIsnull;
  /**
   * 客付税费 比较(isnotnull)
   */
  private Boolean taxIsnotnull;

  /**
   * 小费
   */
  private java.math.BigDecimal tip;

  /**
   * 最小小费
   */
  private java.math.BigDecimal tipMin;

  /**
   * 最大小费
   */
  private java.math.BigDecimal tipMax;

  /**
   * 小费 比较(eq)
   */
  private java.math.BigDecimal tipEq;
  /**
   * 小费 比较(neq)
   */
  private java.math.BigDecimal tipNeq;
  /**
   * 小费 比较(gt)
   */
  private java.math.BigDecimal tipGt;
  /**
   * 小费 比较(gte)
   */
  private java.math.BigDecimal tipGte;
  /**
   * 小费 比较(lt)
   */
  private java.math.BigDecimal tipLt;
  /**
   * 小费 比较(lte)
   */
  private java.math.BigDecimal tipLte;
  /**
   * 小费 比较(contains)
   */
  private java.math.BigDecimal tipContains;
  /**
   * 小费 比较(notcontains)
   */
  private java.math.BigDecimal tipNotcontains;
  /**
   * 小费 比较(startswith)
   */
  private java.math.BigDecimal tipStartswith;
  /**
   * 小费 比较(endswith)
   */
  private java.math.BigDecimal tipEndswith;
  /**
   * 小费 比较(isnull)
   */
  private Boolean tipIsnull;
  /**
   * 小费 比较(isnotnull)
   */
  private Boolean tipIsnotnull;

  /**
   * 折扣
   */
  private java.math.BigDecimal discount;

  /**
   * 最小折扣
   */
  private java.math.BigDecimal discountMin;

  /**
   * 最大折扣
   */
  private java.math.BigDecimal discountMax;

  /**
   * 折扣 比较(eq)
   */
  private java.math.BigDecimal discountEq;
  /**
   * 折扣 比较(neq)
   */
  private java.math.BigDecimal discountNeq;
  /**
   * 折扣 比较(gt)
   */
  private java.math.BigDecimal discountGt;
  /**
   * 折扣 比较(gte)
   */
  private java.math.BigDecimal discountGte;
  /**
   * 折扣 比较(lt)
   */
  private java.math.BigDecimal discountLt;
  /**
   * 折扣 比较(lte)
   */
  private java.math.BigDecimal discountLte;
  /**
   * 折扣 比较(contains)
   */
  private java.math.BigDecimal discountContains;
  /**
   * 折扣 比较(notcontains)
   */
  private java.math.BigDecimal discountNotcontains;
  /**
   * 折扣 比较(startswith)
   */
  private java.math.BigDecimal discountStartswith;
  /**
   * 折扣 比较(endswith)
   */
  private java.math.BigDecimal discountEndswith;
  /**
   * 折扣 比较(isnull)
   */
  private Boolean discountIsnull;
  /**
   * 折扣 比较(isnotnull)
   */
  private Boolean discountIsnotnull;

  /**
   * 商品金额
   */
  private java.math.BigDecimal amount;

  /**
   * 最小商品金额
   */
  private java.math.BigDecimal amountMin;

  /**
   * 最大商品金额
   */
  private java.math.BigDecimal amountMax;

  /**
   * 商品金额 比较(eq)
   */
  private java.math.BigDecimal amountEq;
  /**
   * 商品金额 比较(neq)
   */
  private java.math.BigDecimal amountNeq;
  /**
   * 商品金额 比较(gt)
   */
  private java.math.BigDecimal amountGt;
  /**
   * 商品金额 比较(gte)
   */
  private java.math.BigDecimal amountGte;
  /**
   * 商品金额 比较(lt)
   */
  private java.math.BigDecimal amountLt;
  /**
   * 商品金额 比较(lte)
   */
  private java.math.BigDecimal amountLte;
  /**
   * 商品金额 比较(contains)
   */
  private java.math.BigDecimal amountContains;
  /**
   * 商品金额 比较(notcontains)
   */
  private java.math.BigDecimal amountNotcontains;
  /**
   * 商品金额 比较(startswith)
   */
  private java.math.BigDecimal amountStartswith;
  /**
   * 商品金额 比较(endswith)
   */
  private java.math.BigDecimal amountEndswith;
  /**
   * 商品金额 比较(isnull)
   */
  private Boolean amountIsnull;
  /**
   * 商品金额 比较(isnotnull)
   */
  private Boolean amountIsnotnull;

  /**
   * 预估出库成本
   */
  private java.math.BigDecimal thinkDeliveryCost;

  /**
   * 最小预估出库成本
   */
  private java.math.BigDecimal thinkDeliveryCostMin;

  /**
   * 最大预估出库成本
   */
  private java.math.BigDecimal thinkDeliveryCostMax;

  /**
   * 预估出库成本 比较(eq)
   */
  private java.math.BigDecimal thinkDeliveryCostEq;
  /**
   * 预估出库成本 比较(neq)
   */
  private java.math.BigDecimal thinkDeliveryCostNeq;
  /**
   * 预估出库成本 比较(gt)
   */
  private java.math.BigDecimal thinkDeliveryCostGt;
  /**
   * 预估出库成本 比较(gte)
   */
  private java.math.BigDecimal thinkDeliveryCostGte;
  /**
   * 预估出库成本 比较(lt)
   */
  private java.math.BigDecimal thinkDeliveryCostLt;
  /**
   * 预估出库成本 比较(lte)
   */
  private java.math.BigDecimal thinkDeliveryCostLte;
  /**
   * 预估出库成本 比较(contains)
   */
  private java.math.BigDecimal thinkDeliveryCostContains;
  /**
   * 预估出库成本 比较(notcontains)
   */
  private java.math.BigDecimal thinkDeliveryCostNotcontains;
  /**
   * 预估出库成本 比较(startswith)
   */
  private java.math.BigDecimal thinkDeliveryCostStartswith;
  /**
   * 预估出库成本 比较(endswith)
   */
  private java.math.BigDecimal thinkDeliveryCostEndswith;
  /**
   * 预估出库成本 比较(isnull)
   */
  private Boolean thinkDeliveryCostIsnull;
  /**
   * 预估出库成本 比较(isnotnull)
   */
  private Boolean thinkDeliveryCostIsnotnull;

  /**
   * 预估运费
   */
  private java.math.BigDecimal deliveryThinkFreight;

  /**
   * 最小预估运费
   */
  private java.math.BigDecimal deliveryThinkFreightMin;

  /**
   * 最大预估运费
   */
  private java.math.BigDecimal deliveryThinkFreightMax;

  /**
   * 预估运费 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkFreightEq;
  /**
   * 预估运费 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkFreightNeq;
  /**
   * 预估运费 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkFreightGt;
  /**
   * 预估运费 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkFreightGte;
  /**
   * 预估运费 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkFreightLt;
  /**
   * 预估运费 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkFreightLte;
  /**
   * 预估运费 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkFreightContains;
  /**
   * 预估运费 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkFreightNotcontains;
  /**
   * 预估运费 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkFreightStartswith;
  /**
   * 预估运费 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkFreightEndswith;
  /**
   * 预估运费 比较(isnull)
   */
  private Boolean deliveryThinkFreightIsnull;
  /**
   * 预估运费 比较(isnotnull)
   */
  private Boolean deliveryThinkFreightIsnotnull;

  /**
   * 客付运费
   */
  private java.math.BigDecimal deliveryRealFreight;

  /**
   * 最小客付运费
   */
  private java.math.BigDecimal deliveryRealFreightMin;

  /**
   * 最大客付运费
   */
  private java.math.BigDecimal deliveryRealFreightMax;

  /**
   * 客付运费 比较(eq)
   */
  private java.math.BigDecimal deliveryRealFreightEq;
  /**
   * 客付运费 比较(neq)
   */
  private java.math.BigDecimal deliveryRealFreightNeq;
  /**
   * 客付运费 比较(gt)
   */
  private java.math.BigDecimal deliveryRealFreightGt;
  /**
   * 客付运费 比较(gte)
   */
  private java.math.BigDecimal deliveryRealFreightGte;
  /**
   * 客付运费 比较(lt)
   */
  private java.math.BigDecimal deliveryRealFreightLt;
  /**
   * 客付运费 比较(lte)
   */
  private java.math.BigDecimal deliveryRealFreightLte;
  /**
   * 客付运费 比较(contains)
   */
  private java.math.BigDecimal deliveryRealFreightContains;
  /**
   * 客付运费 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealFreightNotcontains;
  /**
   * 客付运费 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealFreightStartswith;
  /**
   * 客付运费 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealFreightEndswith;
  /**
   * 客付运费 比较(isnull)
   */
  private Boolean deliveryRealFreightIsnull;
  /**
   * 客付运费 比较(isnotnull)
   */
  private Boolean deliveryRealFreightIsnotnull;

  /**
   * 交易费
   */
  private java.math.BigDecimal transactionCost;

  /**
   * 最小交易费
   */
  private java.math.BigDecimal transactionCostMin;

  /**
   * 最大交易费
   */
  private java.math.BigDecimal transactionCostMax;

  /**
   * 交易费 比较(eq)
   */
  private java.math.BigDecimal transactionCostEq;
  /**
   * 交易费 比较(neq)
   */
  private java.math.BigDecimal transactionCostNeq;
  /**
   * 交易费 比较(gt)
   */
  private java.math.BigDecimal transactionCostGt;
  /**
   * 交易费 比较(gte)
   */
  private java.math.BigDecimal transactionCostGte;
  /**
   * 交易费 比较(lt)
   */
  private java.math.BigDecimal transactionCostLt;
  /**
   * 交易费 比较(lte)
   */
  private java.math.BigDecimal transactionCostLte;
  /**
   * 交易费 比较(contains)
   */
  private java.math.BigDecimal transactionCostContains;
  /**
   * 交易费 比较(notcontains)
   */
  private java.math.BigDecimal transactionCostNotcontains;
  /**
   * 交易费 比较(startswith)
   */
  private java.math.BigDecimal transactionCostStartswith;
  /**
   * 交易费 比较(endswith)
   */
  private java.math.BigDecimal transactionCostEndswith;
  /**
   * 交易费 比较(isnull)
   */
  private Boolean transactionCostIsnull;
  /**
   * 交易费 比较(isnotnull)
   */
  private Boolean transactionCostIsnotnull;

  /**
   * 平台其他费
   */
  private java.math.BigDecimal otherAmount;

  /**
   * 最小平台其他费
   */
  private java.math.BigDecimal otherAmountMin;

  /**
   * 最大平台其他费
   */
  private java.math.BigDecimal otherAmountMax;

  /**
   * 平台其他费 比较(eq)
   */
  private java.math.BigDecimal otherAmountEq;
  /**
   * 平台其他费 比较(neq)
   */
  private java.math.BigDecimal otherAmountNeq;
  /**
   * 平台其他费 比较(gt)
   */
  private java.math.BigDecimal otherAmountGt;
  /**
   * 平台其他费 比较(gte)
   */
  private java.math.BigDecimal otherAmountGte;
  /**
   * 平台其他费 比较(lt)
   */
  private java.math.BigDecimal otherAmountLt;
  /**
   * 平台其他费 比较(lte)
   */
  private java.math.BigDecimal otherAmountLte;
  /**
   * 平台其他费 比较(contains)
   */
  private java.math.BigDecimal otherAmountContains;
  /**
   * 平台其他费 比较(notcontains)
   */
  private java.math.BigDecimal otherAmountNotcontains;
  /**
   * 平台其他费 比较(startswith)
   */
  private java.math.BigDecimal otherAmountStartswith;
  /**
   * 平台其他费 比较(endswith)
   */
  private java.math.BigDecimal otherAmountEndswith;
  /**
   * 平台其他费 比较(isnull)
   */
  private Boolean otherAmountIsnull;
  /**
   * 平台其他费 比较(isnotnull)
   */
  private Boolean otherAmountIsnotnull;

  /**
   * 采购成本
   */
  private java.math.BigDecimal cgPriceAmount;

  /**
   * 最小采购成本
   */
  private java.math.BigDecimal cgPriceAmountMin;

  /**
   * 最大采购成本
   */
  private java.math.BigDecimal cgPriceAmountMax;

  /**
   * 采购成本 比较(eq)
   */
  private java.math.BigDecimal cgPriceAmountEq;
  /**
   * 采购成本 比较(neq)
   */
  private java.math.BigDecimal cgPriceAmountNeq;
  /**
   * 采购成本 比较(gt)
   */
  private java.math.BigDecimal cgPriceAmountGt;
  /**
   * 采购成本 比较(gte)
   */
  private java.math.BigDecimal cgPriceAmountGte;
  /**
   * 采购成本 比较(lt)
   */
  private java.math.BigDecimal cgPriceAmountLt;
  /**
   * 采购成本 比较(lte)
   */
  private java.math.BigDecimal cgPriceAmountLte;
  /**
   * 采购成本 比较(contains)
   */
  private java.math.BigDecimal cgPriceAmountContains;
  /**
   * 采购成本 比较(notcontains)
   */
  private java.math.BigDecimal cgPriceAmountNotcontains;
  /**
   * 采购成本 比较(startswith)
   */
  private java.math.BigDecimal cgPriceAmountStartswith;
  /**
   * 采购成本 比较(endswith)
   */
  private java.math.BigDecimal cgPriceAmountEndswith;
  /**
   * 采购成本 比较(isnull)
   */
  private Boolean cgPriceAmountIsnull;
  /**
   * 采购成本 比较(isnotnull)
   */
  private Boolean cgPriceAmountIsnotnull;

  /**
   * 库存明细成本
   */
  private java.math.BigDecimal stockAostAmount;

  /**
   * 最小库存明细成本
   */
  private java.math.BigDecimal stockAostAmountMin;

  /**
   * 最大库存明细成本
   */
  private java.math.BigDecimal stockAostAmountMax;

  /**
   * 库存明细成本 比较(eq)
   */
  private java.math.BigDecimal stockAostAmountEq;
  /**
   * 库存明细成本 比较(neq)
   */
  private java.math.BigDecimal stockAostAmountNeq;
  /**
   * 库存明细成本 比较(gt)
   */
  private java.math.BigDecimal stockAostAmountGt;
  /**
   * 库存明细成本 比较(gte)
   */
  private java.math.BigDecimal stockAostAmountGte;
  /**
   * 库存明细成本 比较(lt)
   */
  private java.math.BigDecimal stockAostAmountLt;
  /**
   * 库存明细成本 比较(lte)
   */
  private java.math.BigDecimal stockAostAmountLte;
  /**
   * 库存明细成本 比较(contains)
   */
  private java.math.BigDecimal stockAostAmountContains;
  /**
   * 库存明细成本 比较(notcontains)
   */
  private java.math.BigDecimal stockAostAmountNotcontains;
  /**
   * 库存明细成本 比较(startswith)
   */
  private java.math.BigDecimal stockAostAmountStartswith;
  /**
   * 库存明细成本 比较(endswith)
   */
  private java.math.BigDecimal stockAostAmountEndswith;
  /**
   * 库存明细成本 比较(isnull)
   */
  private Boolean stockAostAmountIsnull;
  /**
   * 库存明细成本 比较(isnotnull)
   */
  private Boolean stockAostAmountIsnotnull;

  /**
   * 实际出库成本
   */
  private java.math.BigDecimal wmsOutboundCostAmount;

  /**
   * 最小实际出库成本
   */
  private java.math.BigDecimal wmsOutboundCostAmountMin;

  /**
   * 最大实际出库成本
   */
  private java.math.BigDecimal wmsOutboundCostAmountMax;

  /**
   * 实际出库成本 比较(eq)
   */
  private java.math.BigDecimal wmsOutboundCostAmountEq;
  /**
   * 实际出库成本 比较(neq)
   */
  private java.math.BigDecimal wmsOutboundCostAmountNeq;
  /**
   * 实际出库成本 比较(gt)
   */
  private java.math.BigDecimal wmsOutboundCostAmountGt;
  /**
   * 实际出库成本 比较(gte)
   */
  private java.math.BigDecimal wmsOutboundCostAmountGte;
  /**
   * 实际出库成本 比较(lt)
   */
  private java.math.BigDecimal wmsOutboundCostAmountLt;
  /**
   * 实际出库成本 比较(lte)
   */
  private java.math.BigDecimal wmsOutboundCostAmountLte;
  /**
   * 实际出库成本 比较(contains)
   */
  private java.math.BigDecimal wmsOutboundCostAmountContains;
  /**
   * 实际出库成本 比较(notcontains)
   */
  private java.math.BigDecimal wmsOutboundCostAmountNotcontains;
  /**
   * 实际出库成本 比较(startswith)
   */
  private java.math.BigDecimal wmsOutboundCostAmountStartswith;
  /**
   * 实际出库成本 比较(endswith)
   */
  private java.math.BigDecimal wmsOutboundCostAmountEndswith;
  /**
   * 实际出库成本 比较(isnull)
   */
  private Boolean wmsOutboundCostAmountIsnull;
  /**
   * 实际出库成本 比较(isnotnull)
   */
  private Boolean wmsOutboundCostAmountIsnotnull;

  /**
   * COD费用
   */
  private java.math.BigDecimal codAmount;

  /**
   * 最小COD费用
   */
  private java.math.BigDecimal codAmountMin;

  /**
   * 最大COD费用
   */
  private java.math.BigDecimal codAmountMax;

  /**
   * COD费用 比较(eq)
   */
  private java.math.BigDecimal codAmountEq;
  /**
   * COD费用 比较(neq)
   */
  private java.math.BigDecimal codAmountNeq;
  /**
   * COD费用 比较(gt)
   */
  private java.math.BigDecimal codAmountGt;
  /**
   * COD费用 比较(gte)
   */
  private java.math.BigDecimal codAmountGte;
  /**
   * COD费用 比较(lt)
   */
  private java.math.BigDecimal codAmountLt;
  /**
   * COD费用 比较(lte)
   */
  private java.math.BigDecimal codAmountLte;
  /**
   * COD费用 比较(contains)
   */
  private java.math.BigDecimal codAmountContains;
  /**
   * COD费用 比较(notcontains)
   */
  private java.math.BigDecimal codAmountNotcontains;
  /**
   * COD费用 比较(startswith)
   */
  private java.math.BigDecimal codAmountStartswith;
  /**
   * COD费用 比较(endswith)
   */
  private java.math.BigDecimal codAmountEndswith;
  /**
   * COD费用 比较(isnull)
   */
  private Boolean codAmountIsnull;
  /**
   * COD费用 比较(isnotnull)
   */
  private Boolean codAmountIsnotnull;

  /**
   * 实际运费
   */
  private java.math.BigDecimal wmsShippingPriceAmount;

  /**
   * 最小实际运费
   */
  private java.math.BigDecimal wmsShippingPriceAmountMin;

  /**
   * 最大实际运费
   */
  private java.math.BigDecimal wmsShippingPriceAmountMax;

  /**
   * 实际运费 比较(eq)
   */
  private java.math.BigDecimal wmsShippingPriceAmountEq;
  /**
   * 实际运费 比较(neq)
   */
  private java.math.BigDecimal wmsShippingPriceAmountNeq;
  /**
   * 实际运费 比较(gt)
   */
  private java.math.BigDecimal wmsShippingPriceAmountGt;
  /**
   * 实际运费 比较(gte)
   */
  private java.math.BigDecimal wmsShippingPriceAmountGte;
  /**
   * 实际运费 比较(lt)
   */
  private java.math.BigDecimal wmsShippingPriceAmountLt;
  /**
   * 实际运费 比较(lte)
   */
  private java.math.BigDecimal wmsShippingPriceAmountLte;
  /**
   * 实际运费 比较(contains)
   */
  private java.math.BigDecimal wmsShippingPriceAmountContains;
  /**
   * 实际运费 比较(notcontains)
   */
  private java.math.BigDecimal wmsShippingPriceAmountNotcontains;
  /**
   * 实际运费 比较(startswith)
   */
  private java.math.BigDecimal wmsShippingPriceAmountStartswith;
  /**
   * 实际运费 比较(endswith)
   */
  private java.math.BigDecimal wmsShippingPriceAmountEndswith;
  /**
   * 实际运费 比较(isnull)
   */
  private Boolean wmsShippingPriceAmountIsnull;
  /**
   * 实际运费 比较(isnotnull)
   */
  private Boolean wmsShippingPriceAmountIsnotnull;

  /**
   * 礼品包装费
   */
  private java.math.BigDecimal giftWrapAmount;

  /**
   * 最小礼品包装费
   */
  private java.math.BigDecimal giftWrapAmountMin;

  /**
   * 最大礼品包装费
   */
  private java.math.BigDecimal giftWrapAmountMax;

  /**
   * 礼品包装费 比较(eq)
   */
  private java.math.BigDecimal giftWrapAmountEq;
  /**
   * 礼品包装费 比较(neq)
   */
  private java.math.BigDecimal giftWrapAmountNeq;
  /**
   * 礼品包装费 比较(gt)
   */
  private java.math.BigDecimal giftWrapAmountGt;
  /**
   * 礼品包装费 比较(gte)
   */
  private java.math.BigDecimal giftWrapAmountGte;
  /**
   * 礼品包装费 比较(lt)
   */
  private java.math.BigDecimal giftWrapAmountLt;
  /**
   * 礼品包装费 比较(lte)
   */
  private java.math.BigDecimal giftWrapAmountLte;
  /**
   * 礼品包装费 比较(contains)
   */
  private java.math.BigDecimal giftWrapAmountContains;
  /**
   * 礼品包装费 比较(notcontains)
   */
  private java.math.BigDecimal giftWrapAmountNotcontains;
  /**
   * 礼品包装费 比较(startswith)
   */
  private java.math.BigDecimal giftWrapAmountStartswith;
  /**
   * 礼品包装费 比较(endswith)
   */
  private java.math.BigDecimal giftWrapAmountEndswith;
  /**
   * 礼品包装费 比较(isnull)
   */
  private Boolean giftWrapAmountIsnull;
  /**
   * 礼品包装费 比较(isnotnull)
   */
  private Boolean giftWrapAmountIsnotnull;

  /**
   * 销售税
   */
  private java.math.BigDecimal saleTax;

  /**
   * 最小销售税
   */
  private java.math.BigDecimal saleTaxMin;

  /**
   * 最大销售税
   */
  private java.math.BigDecimal saleTaxMax;

  /**
   * 销售税 比较(eq)
   */
  private java.math.BigDecimal saleTaxEq;
  /**
   * 销售税 比较(neq)
   */
  private java.math.BigDecimal saleTaxNeq;
  /**
   * 销售税 比较(gt)
   */
  private java.math.BigDecimal saleTaxGt;
  /**
   * 销售税 比较(gte)
   */
  private java.math.BigDecimal saleTaxGte;
  /**
   * 销售税 比较(lt)
   */
  private java.math.BigDecimal saleTaxLt;
  /**
   * 销售税 比较(lte)
   */
  private java.math.BigDecimal saleTaxLte;
  /**
   * 销售税 比较(contains)
   */
  private java.math.BigDecimal saleTaxContains;
  /**
   * 销售税 比较(notcontains)
   */
  private java.math.BigDecimal saleTaxNotcontains;
  /**
   * 销售税 比较(startswith)
   */
  private java.math.BigDecimal saleTaxStartswith;
  /**
   * 销售税 比较(endswith)
   */
  private java.math.BigDecimal saleTaxEndswith;
  /**
   * 销售税 比较(isnull)
   */
  private Boolean saleTaxIsnull;
  /**
   * 销售税 比较(isnotnull)
   */
  private Boolean saleTaxIsnotnull;

  /**
   * 积分成本
   */
  private java.math.BigDecimal pointsGrantedAmount;

  /**
   * 最小积分成本
   */
  private java.math.BigDecimal pointsGrantedAmountMin;

  /**
   * 最大积分成本
   */
  private java.math.BigDecimal pointsGrantedAmountMax;

  /**
   * 积分成本 比较(eq)
   */
  private java.math.BigDecimal pointsGrantedAmountEq;
  /**
   * 积分成本 比较(neq)
   */
  private java.math.BigDecimal pointsGrantedAmountNeq;
  /**
   * 积分成本 比较(gt)
   */
  private java.math.BigDecimal pointsGrantedAmountGt;
  /**
   * 积分成本 比较(gte)
   */
  private java.math.BigDecimal pointsGrantedAmountGte;
  /**
   * 积分成本 比较(lt)
   */
  private java.math.BigDecimal pointsGrantedAmountLt;
  /**
   * 积分成本 比较(lte)
   */
  private java.math.BigDecimal pointsGrantedAmountLte;
  /**
   * 积分成本 比较(contains)
   */
  private java.math.BigDecimal pointsGrantedAmountContains;
  /**
   * 积分成本 比较(notcontains)
   */
  private java.math.BigDecimal pointsGrantedAmountNotcontains;
  /**
   * 积分成本 比较(startswith)
   */
  private java.math.BigDecimal pointsGrantedAmountStartswith;
  /**
   * 积分成本 比较(endswith)
   */
  private java.math.BigDecimal pointsGrantedAmountEndswith;
  /**
   * 积分成本 比较(isnull)
   */
  private Boolean pointsGrantedAmountIsnull;
  /**
   * 积分成本 比较(isnotnull)
   */
  private Boolean pointsGrantedAmountIsnotnull;

  /**
   * 其他费用
   */
  private java.math.BigDecimal otherFee;

  /**
   * 最小其他费用
   */
  private java.math.BigDecimal otherFeeMin;

  /**
   * 最大其他费用
   */
  private java.math.BigDecimal otherFeeMax;

  /**
   * 其他费用 比较(eq)
   */
  private java.math.BigDecimal otherFeeEq;
  /**
   * 其他费用 比较(neq)
   */
  private java.math.BigDecimal otherFeeNeq;
  /**
   * 其他费用 比较(gt)
   */
  private java.math.BigDecimal otherFeeGt;
  /**
   * 其他费用 比较(gte)
   */
  private java.math.BigDecimal otherFeeGte;
  /**
   * 其他费用 比较(lt)
   */
  private java.math.BigDecimal otherFeeLt;
  /**
   * 其他费用 比较(lte)
   */
  private java.math.BigDecimal otherFeeLte;
  /**
   * 其他费用 比较(contains)
   */
  private java.math.BigDecimal otherFeeContains;
  /**
   * 其他费用 比较(notcontains)
   */
  private java.math.BigDecimal otherFeeNotcontains;
  /**
   * 其他费用 比较(startswith)
   */
  private java.math.BigDecimal otherFeeStartswith;
  /**
   * 其他费用 比较(endswith)
   */
  private java.math.BigDecimal otherFeeEndswith;
  /**
   * 其他费用 比较(isnull)
   */
  private Boolean otherFeeIsnull;
  /**
   * 其他费用 比较(isnotnull)
   */
  private Boolean otherFeeIsnotnull;

  /**
   * 平台订单商品状态
   */
  private String platformStatus;

  /**
   * 平台订单商品状态 比较(eq)
   */
  private String platformStatusEq;
  /**
   * 平台订单商品状态 比较(neq)
   */
  private String platformStatusNeq;
  /**
   * 平台订单商品状态 比较(gt)
   */
  private String platformStatusGt;
  /**
   * 平台订单商品状态 比较(gte)
   */
  private String platformStatusGte;
  /**
   * 平台订单商品状态 比较(lt)
   */
  private String platformStatusLt;
  /**
   * 平台订单商品状态 比较(lte)
   */
  private String platformStatusLte;
  /**
   * 平台订单商品状态 比较(contains)
   */
  private String platformStatusContains;
  /**
   * 平台订单商品状态 比较(notcontains)
   */
  private String platformStatusNotcontains;
  /**
   * 平台订单商品状态 比较(startswith)
   */
  private String platformStatusStartswith;
  /**
   * 平台订单商品状态 比较(endswith)
   */
  private String platformStatusEndswith;
  /**
   * 平台订单商品状态 比较(isnull)
   */
  private Boolean platformStatusIsnull;
  /**
   * 平台订单商品状态 比较(isnotnull)
   */
  private Boolean platformStatusIsnotnull;

  /**
   * 平台订单商品状态(精确搜索)
   */
  private List<String> platformStatusInList;

  /**
   * 商品备注(模糊搜索)
   */
  private String remark;

  /**
   * 商品备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 商品备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 商品备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 商品备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 商品备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 商品备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 商品备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 商品备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 商品备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 商品备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 商品备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 商品备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 商品备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 估算重量单位
   */
  private String deliveryThinkWeightUnit;

  /**
   * 估算重量单位 比较(eq)
   */
  private String deliveryThinkWeightUnitEq;
  /**
   * 估算重量单位 比较(neq)
   */
  private String deliveryThinkWeightUnitNeq;
  /**
   * 估算重量单位 比较(gt)
   */
  private String deliveryThinkWeightUnitGt;
  /**
   * 估算重量单位 比较(gte)
   */
  private String deliveryThinkWeightUnitGte;
  /**
   * 估算重量单位 比较(lt)
   */
  private String deliveryThinkWeightUnitLt;
  /**
   * 估算重量单位 比较(lte)
   */
  private String deliveryThinkWeightUnitLte;
  /**
   * 估算重量单位 比较(contains)
   */
  private String deliveryThinkWeightUnitContains;
  /**
   * 估算重量单位 比较(notcontains)
   */
  private String deliveryThinkWeightUnitNotcontains;
  /**
   * 估算重量单位 比较(startswith)
   */
  private String deliveryThinkWeightUnitStartswith;
  /**
   * 估算重量单位 比较(endswith)
   */
  private String deliveryThinkWeightUnitEndswith;
  /**
   * 估算重量单位 比较(isnull)
   */
  private Boolean deliveryThinkWeightUnitIsnull;
  /**
   * 估算重量单位 比较(isnotnull)
   */
  private Boolean deliveryThinkWeightUnitIsnotnull;

  /**
   * 估算重量单位(精确搜索)
   */
  private List<String> deliveryThinkWeightUnitInList;

  /**
   * 估算重量
   */
  private java.math.BigDecimal deliveryThinkWeight;

  /**
   * 最小估算重量
   */
  private java.math.BigDecimal deliveryThinkWeightMin;

  /**
   * 最大估算重量
   */
  private java.math.BigDecimal deliveryThinkWeightMax;

  /**
   * 估算重量 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkWeightEq;
  /**
   * 估算重量 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkWeightNeq;
  /**
   * 估算重量 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkWeightGt;
  /**
   * 估算重量 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkWeightGte;
  /**
   * 估算重量 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkWeightLt;
  /**
   * 估算重量 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkWeightLte;
  /**
   * 估算重量 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkWeightContains;
  /**
   * 估算重量 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkWeightNotcontains;
  /**
   * 估算重量 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkWeightStartswith;
  /**
   * 估算重量 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkWeightEndswith;
  /**
   * 估算重量 比较(isnull)
   */
  private Boolean deliveryThinkWeightIsnull;
  /**
   * 估算重量 比较(isnotnull)
   */
  private Boolean deliveryThinkWeightIsnotnull;

  /**
   * 商品标题(模糊搜索)
   */
  private String goodsTitle;

  /**
   * 商品标题 比较(eq)
   */
  private String goodsTitleEq;
  /**
   * 商品标题 比较(neq)
   */
  private String goodsTitleNeq;
  /**
   * 商品标题 比较(gt)
   */
  private String goodsTitleGt;
  /**
   * 商品标题 比较(gte)
   */
  private String goodsTitleGte;
  /**
   * 商品标题 比较(lt)
   */
  private String goodsTitleLt;
  /**
   * 商品标题 比较(lte)
   */
  private String goodsTitleLte;
  /**
   * 商品标题 比较(contains)
   */
  private String goodsTitleContains;
  /**
   * 商品标题 比较(notcontains)
   */
  private String goodsTitleNotcontains;
  /**
   * 商品标题 比较(startswith)
   */
  private String goodsTitleStartswith;
  /**
   * 商品标题 比较(endswith)
   */
  private String goodsTitleEndswith;
  /**
   * 商品标题 比较(isnull)
   */
  private Boolean goodsTitleIsnull;
  /**
   * 商品标题 比较(isnotnull)
   */
  private Boolean goodsTitleIsnotnull;

  /**
   * 商品标题(精确搜索)
   */
  private List<String> goodsTitleInList;

  /**
   * 商品ID(模糊搜索)
   */
  private String goodsCode;

  /**
   * 商品ID 比较(eq)
   */
  private String goodsCodeEq;
  /**
   * 商品ID 比较(neq)
   */
  private String goodsCodeNeq;
  /**
   * 商品ID 比较(gt)
   */
  private String goodsCodeGt;
  /**
   * 商品ID 比较(gte)
   */
  private String goodsCodeGte;
  /**
   * 商品ID 比较(lt)
   */
  private String goodsCodeLt;
  /**
   * 商品ID 比较(lte)
   */
  private String goodsCodeLte;
  /**
   * 商品ID 比较(contains)
   */
  private String goodsCodeContains;
  /**
   * 商品ID 比较(notcontains)
   */
  private String goodsCodeNotcontains;
  /**
   * 商品ID 比较(startswith)
   */
  private String goodsCodeStartswith;
  /**
   * 商品ID 比较(endswith)
   */
  private String goodsCodeEndswith;
  /**
   * 商品ID 比较(isnull)
   */
  private Boolean goodsCodeIsnull;
  /**
   * 商品ID 比较(isnotnull)
   */
  private Boolean goodsCodeIsnotnull;

  /**
   * 商品ID(精确搜索)
   */
  private List<String> goodsCodeInList;

  /**
   * 卖家订单id(模糊搜索)
   */
  private String sellerOrderId;

  /**
   * 卖家订单id 比较(eq)
   */
  private String sellerOrderIdEq;
  /**
   * 卖家订单id 比较(neq)
   */
  private String sellerOrderIdNeq;
  /**
   * 卖家订单id 比较(gt)
   */
  private String sellerOrderIdGt;
  /**
   * 卖家订单id 比较(gte)
   */
  private String sellerOrderIdGte;
  /**
   * 卖家订单id 比较(lt)
   */
  private String sellerOrderIdLt;
  /**
   * 卖家订单id 比较(lte)
   */
  private String sellerOrderIdLte;
  /**
   * 卖家订单id 比较(contains)
   */
  private String sellerOrderIdContains;
  /**
   * 卖家订单id 比较(notcontains)
   */
  private String sellerOrderIdNotcontains;
  /**
   * 卖家订单id 比较(startswith)
   */
  private String sellerOrderIdStartswith;
  /**
   * 卖家订单id 比较(endswith)
   */
  private String sellerOrderIdEndswith;
  /**
   * 卖家订单id 比较(isnull)
   */
  private Boolean sellerOrderIdIsnull;
  /**
   * 卖家订单id 比较(isnotnull)
   */
  private Boolean sellerOrderIdIsnotnull;

  /**
   * 卖家订单id(精确搜索)
   */
  private List<String> sellerOrderIdInList;

  /**
   * 行号（沃尔玛订单）(模糊搜索)
   */
  private String lineNumber;

  /**
   * 行号（沃尔玛订单） 比较(eq)
   */
  private String lineNumberEq;
  /**
   * 行号（沃尔玛订单） 比较(neq)
   */
  private String lineNumberNeq;
  /**
   * 行号（沃尔玛订单） 比较(gt)
   */
  private String lineNumberGt;
  /**
   * 行号（沃尔玛订单） 比较(gte)
   */
  private String lineNumberGte;
  /**
   * 行号（沃尔玛订单） 比较(lt)
   */
  private String lineNumberLt;
  /**
   * 行号（沃尔玛订单） 比较(lte)
   */
  private String lineNumberLte;
  /**
   * 行号（沃尔玛订单） 比较(contains)
   */
  private String lineNumberContains;
  /**
   * 行号（沃尔玛订单） 比较(notcontains)
   */
  private String lineNumberNotcontains;
  /**
   * 行号（沃尔玛订单） 比较(startswith)
   */
  private String lineNumberStartswith;
  /**
   * 行号（沃尔玛订单） 比较(endswith)
   */
  private String lineNumberEndswith;
  /**
   * 行号（沃尔玛订单） 比较(isnull)
   */
  private Boolean lineNumberIsnull;
  /**
   * 行号（沃尔玛订单） 比较(isnotnull)
   */
  private Boolean lineNumberIsnotnull;

  /**
   * 行号（沃尔玛订单）(精确搜索)
   */
  private List<String> lineNumberInList;

  /**
   * 数量单位(模糊搜索)
   */
  private String unitOfMeasurement;

  /**
   * 数量单位 比较(eq)
   */
  private String unitOfMeasurementEq;
  /**
   * 数量单位 比较(neq)
   */
  private String unitOfMeasurementNeq;
  /**
   * 数量单位 比较(gt)
   */
  private String unitOfMeasurementGt;
  /**
   * 数量单位 比较(gte)
   */
  private String unitOfMeasurementGte;
  /**
   * 数量单位 比较(lt)
   */
  private String unitOfMeasurementLt;
  /**
   * 数量单位 比较(lte)
   */
  private String unitOfMeasurementLte;
  /**
   * 数量单位 比较(contains)
   */
  private String unitOfMeasurementContains;
  /**
   * 数量单位 比较(notcontains)
   */
  private String unitOfMeasurementNotcontains;
  /**
   * 数量单位 比较(startswith)
   */
  private String unitOfMeasurementStartswith;
  /**
   * 数量单位 比较(endswith)
   */
  private String unitOfMeasurementEndswith;
  /**
   * 数量单位 比较(isnull)
   */
  private Boolean unitOfMeasurementIsnull;
  /**
   * 数量单位 比较(isnotnull)
   */
  private Boolean unitOfMeasurementIsnotnull;

  /**
   * 数量单位(精确搜索)
   */
  private List<String> unitOfMeasurementInList;

  /**
   * 是否此时配对
   */
  private String nowPari;

  /**
   * 是否此时配对 比较(eq)
   */
  private String nowPariEq;
  /**
   * 是否此时配对 比较(neq)
   */
  private String nowPariNeq;
  /**
   * 是否此时配对 比较(gt)
   */
  private String nowPariGt;
  /**
   * 是否此时配对 比较(gte)
   */
  private String nowPariGte;
  /**
   * 是否此时配对 比较(lt)
   */
  private String nowPariLt;
  /**
   * 是否此时配对 比较(lte)
   */
  private String nowPariLte;
  /**
   * 是否此时配对 比较(contains)
   */
  private String nowPariContains;
  /**
   * 是否此时配对 比较(notcontains)
   */
  private String nowPariNotcontains;
  /**
   * 是否此时配对 比较(startswith)
   */
  private String nowPariStartswith;
  /**
   * 是否此时配对 比较(endswith)
   */
  private String nowPariEndswith;
  /**
   * 是否此时配对 比较(isnull)
   */
  private Boolean nowPariIsnull;
  /**
   * 是否此时配对 比较(isnotnull)
   */
  private Boolean nowPariIsnotnull;

  /**
   * 是否此时配对(精确搜索)
   */
  private List<String> nowPariInList;

  /**
   * 实重
   */
  private java.math.BigDecimal deliveryRealWeight;

  /**
   * 最小实重
   */
  private java.math.BigDecimal deliveryRealWeightMin;

  /**
   * 最大实重
   */
  private java.math.BigDecimal deliveryRealWeightMax;

  /**
   * 实重 比较(eq)
   */
  private java.math.BigDecimal deliveryRealWeightEq;
  /**
   * 实重 比较(neq)
   */
  private java.math.BigDecimal deliveryRealWeightNeq;
  /**
   * 实重 比较(gt)
   */
  private java.math.BigDecimal deliveryRealWeightGt;
  /**
   * 实重 比较(gte)
   */
  private java.math.BigDecimal deliveryRealWeightGte;
  /**
   * 实重 比较(lt)
   */
  private java.math.BigDecimal deliveryRealWeightLt;
  /**
   * 实重 比较(lte)
   */
  private java.math.BigDecimal deliveryRealWeightLte;
  /**
   * 实重 比较(contains)
   */
  private java.math.BigDecimal deliveryRealWeightContains;
  /**
   * 实重 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealWeightNotcontains;
  /**
   * 实重 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealWeightStartswith;
  /**
   * 实重 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealWeightEndswith;
  /**
   * 实重 比较(isnull)
   */
  private Boolean deliveryRealWeightIsnull;
  /**
   * 实重 比较(isnotnull)
   */
  private Boolean deliveryRealWeightIsnotnull;

  /**
   * 实重单位
   */
  private String deliveryRealWeightUnit;

  /**
   * 实重单位 比较(eq)
   */
  private String deliveryRealWeightUnitEq;
  /**
   * 实重单位 比较(neq)
   */
  private String deliveryRealWeightUnitNeq;
  /**
   * 实重单位 比较(gt)
   */
  private String deliveryRealWeightUnitGt;
  /**
   * 实重单位 比较(gte)
   */
  private String deliveryRealWeightUnitGte;
  /**
   * 实重单位 比较(lt)
   */
  private String deliveryRealWeightUnitLt;
  /**
   * 实重单位 比较(lte)
   */
  private String deliveryRealWeightUnitLte;
  /**
   * 实重单位 比较(contains)
   */
  private String deliveryRealWeightUnitContains;
  /**
   * 实重单位 比较(notcontains)
   */
  private String deliveryRealWeightUnitNotcontains;
  /**
   * 实重单位 比较(startswith)
   */
  private String deliveryRealWeightUnitStartswith;
  /**
   * 实重单位 比较(endswith)
   */
  private String deliveryRealWeightUnitEndswith;
  /**
   * 实重单位 比较(isnull)
   */
  private Boolean deliveryRealWeightUnitIsnull;
  /**
   * 实重单位 比较(isnotnull)
   */
  private Boolean deliveryRealWeightUnitIsnotnull;

  /**
   * 实重单位(精确搜索)
   */
  private List<String> deliveryRealWeightUnitInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
